applications/positionmanager/src/positionmanager/portfolio.py (3)

11-16: Min/max tickers ctor parameters are unused

The initializer captures minimum_portfolio_tickers and maximum_portfolio_tickers, but they aren’t enforced in get_optimized_portfolio. Either implement enforcement or remove the parameters to avoid confusion.

Options:

• Enforce max by zeroing smallest weights until non-zero count ≤ maximum_portfolio_tickers.
• Enforce min by boosting weights of top-N assets or adding a post-optimization selection heuristic.

I can provide a small post-processing helper that trims weights to top-N by absolute weight and re-normalizes.

---

22-23: Validate prediction_weight ∈ [0, 1]

Guard against invalid values to avoid unintentionally flipping the sign or overweighting predictions.

Suggested change:

     prediction_weight: float = 0.3,
 ) -> dict[str, int]:
-        converted_data = historical_data.to_pandas()
+        if not 0.0 <= prediction_weight <= 1.0:
+            raise ValueError("prediction_weight must be between 0 and 1 inclusive")
+        converted_data = historical_data.to_pandas()

---

54-55: Avoid truncating portfolio value to an int

Casting Money to float and then to int truncates cents, systematically under-allocating capital. DiscreteAllocation accepts floats; preserve precision.

-            total_portfolio_value=int(float(portfolio_value)),
+            total_portfolio_value=float(portfolio_value),

pyproject.toml (1)

17-28: Pytest rootdir points to a non-existent path; likely breaks test discovery

Setting --rootdir=/tests while tests live under applications/*/tests and libraries/python/tests can cause test discovery issues.

Consider removing rootdir or pointing it to the repo root.

 addopts = [
     "--verbose",
     "--tb=short",
     "--strict-markers",
     "--color=yes",
-    "--rootdir=/tests",
 ]

libraries/python/src/internal/dates.py (1)

38-45: Type annotations in validator should use datetime.date, not datetime.datetime

start and end are datetime.date, but the validator type hints are datetime.datetime. This is misleading and could confuse IDEs/type-checkers.

Apply this diff:

-    def check_end_after_start(
-        cls,
-        end_value: datetime.datetime,
-        info: core_schema.ValidationInfo,
-    ) -> datetime.datetime:
+    def check_end_after_start(
+        cls,
+        end_value: datetime.date,
+        info: core_schema.ValidationInfo,
+    ) -> datetime.date:

applications/datamanager/src/datamanager/main.py (1)

179-191: Content-Type mismatch: writing Arrow stream but declaring file; fix media_type and Content-Disposition.

You’re using pa.ipc.RecordBatchStreamWriter (stream format) but returning media_type="application/vnd.apache.arrow.file". Use the stream media type and standard Content-Disposition formatting.

Apply this diff:

-            content_disposition = f"attachment; {filename=}"
+            content_disposition = f'attachment; filename="{filename}"'
...
-        return Response(
-            content=sink.getvalue().to_pybytes(),
-            media_type="application/vnd.apache.arrow.file",
+        return Response(
+            content=sink.getvalue().to_pybytes(),
+            media_type="application/vnd.apache.arrow.stream",
             headers={
                 "Content-Disposition": content_disposition,
                 "X-Row-Count": str(data.num_rows),
                 "X-Start-Date": str(start_date),
                 "X-End-Date": str(end_date),
             },
         )

applications/positionmanager/tests/test_positionmanager_main.py (1)

88-106: Handle HTTPException in /positions/open so errors return CloudEvent

Verified: open_position returns CloudEvent for several exceptions but does NOT catch fastapi.HTTPException. The tests set AlpacaClient.get_cash_balance to raise HTTPException, which currently bubbles up (resulting in a 500) — that's why the test expects a 500. To make error handling consistent, convert HTTPException into a CloudEvent error.

Actionable changes:

• applications/positionmanager/src/positionmanager/main.py

  • In open_position (around @application.post("/positions/open")), include HTTPException in the except clause that handles get_cash_balance (or add a dedicated except HTTPException to return create_cloud_event_error). Example:
    except (HTTPException, requests.RequestException, APIError, ValidationError) as e:
    return create_cloud_event_error(...)

• applications/positionmanager/tests/test_positionmanager_main.py

  • Update test_open_position_alpaca_error to assert the standardized CloudEvent error response (and status code consistent with your contract) instead of asserting a raw 500 and HTTPException detail.

Reasoning (short): current behavior is intentional given the code, but inconsistent with the rest of the endpoint's CloudEvent error returns — adding HTTPException handling (or a global handler) will align runtime behavior and tests.

applications/positionmanager/src/positionmanager/main.py (1)

175-183: Guard against missing percentile_50 in predictions to avoid KeyError.

Use .get and filter only valid entries.

Apply this diff:

-        predictions_percentile_50 = {
-            key: value["percentile_50"] for key, value in predictions.items()
-        }
+        predictions_percentile_50 = {
+            key: value.get("percentile_50")
+            for key, value in predictions.items()
+            if isinstance(value, dict) and "percentile_50" in value
+        }

libraries/python/src/internal/loss_functions.py (1)

20-26: Bug: add() result is unused; loss accumulation is a no-op without assignment

In tinygrad most ops return new tensors. errors_total.add(...) does not mutate in place; you need to assign back. This matches a prior review comment.

-        errors_total.add(
+        errors_total = errors_total.add(
             Tensor.where(
                 error > 0,
                 quantile_tensor.mul(error),
                 (quantile_tensor.sub(1)).mul(error),
             ).mean()
         )

applications/models/pyproject.toml (1)

7-19: Remove duplicate 'internal==0.1.0' dependency

The 'internal' dependency is listed twice (Lines 7 and 13). Keep a single entry to avoid resolver confusion.

Apply this diff:

 dependencies = [
-    "internal==0.1.0",
+    "internal==0.1.0",
@@
-    "polygon-api-client>=1.14.6",
-    "internal==0.1.0",
+    "polygon-api-client>=1.14.6",

Additionally, since you’re using a UV workspace source below, you can depend on the workspace package without pinning a version to avoid conflicts between the lock and local workspace:

```diff
-[tool.uv.sources]
-internal = { workspace = true }
+[tool.uv.sources]
+internal = { workspace = true }

And update the dependency to reference the workspace:

-    "internal==0.1.0",
+    "internal",

If you prefer to keep the exact version pin for releases, do it in non-workspace builds only (e.g., via an env-driven dependency override).

libraries/python/src/internal/lstm_network.py (1)

80-80: Tensor.stack likely fails for a single-timestep sequence

Tinygrad’s Tensor.stack generally expects multiple tensors. The previous code handled the single-output case via unsqueeze. Restore that branch to prevent runtime errors when sequence_length == 1.

Apply this diff:

-        output_tensor = Tensor.stack(outputs[0], *outputs[1:], dim=1)
+        if len(outputs) == 1:
+            output_tensor = outputs[0].unsqueeze(dim=1)
+        else:
+            output_tensor = Tensor.stack(outputs[0], *outputs[1:], dim=1)

applications/datamanager/src/datamanager/main.py (1)

265-281: Broad exception mapped to 404; return 500 on listing error and clarify log message.

An exception when listing S3 objects is not “not found”; it’s an internal error. Also, error message should reflect the actual operation.

Apply this diff:

-    try:
-        blobs = list(s3_client.list_objects(prefix=prefix))
-    except Exception as e:  # noqa: BLE001
-        logger.error(f"Error listing S3 objects: {e}")
-        return Response(
-            status_code=status.HTTP_404_NOT_FOUND,
-            content=json.dumps({"error": "No equity bars found"}),
-            media_type="application/json",
-        )
+    try:
+        blobs = list(s3_client.list_objects(prefix=prefix))
+    except Exception as e:  # noqa: BLE001
+        logger.error(f"Error listing equity bars: {e}")
+        return Response(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=json.dumps({"error": "Failed to list equity bars"}),
+            media_type="application/json",
+        )

applications/positionmanager/src/positionmanager/portfolio.py (3)

26-31: Indexing date column: ensure proper dtype

Setting the index to "date" is correct; consider ensuring a datetime index for robustness with time-based operations.

Optional:

-        if "date" in converted_data.columns:
-            converted_data = converted_data.set_index("date")
+        if "date" in converted_data.columns:
+            converted_data["date"] = pd.to_datetime(converted_data["date"], errors="coerce")
+            converted_data = converted_data.set_index("date").dropna(axis=0, how="any")

---

46-47: Make risk-free rate configurable

Hardcoding 2% limits reuse across environments. Consider an argument or class attribute.

-        efficient_frontier.max_sharpe(risk_free_rate=0.02)  # 2% risk-free rate
+        efficient_frontier.max_sharpe(risk_free_rate=getattr(self, "risk_free_rate", 0.02))

---

57-59: Consider lp_portfolio for better discrete allocation

greedy_portfolio is fast but suboptimal. If runtime allows (and solver deps are present), lp_portfolio can yield better allocations and help adhere to constraints (e.g., bounds).

Example:

optimized_portfolio_ticker_share_counts, _ = discrete_allocation.lp_portfolio()

Keep greedy as a fallback if solver unavailable.

applications/positionmanager/pyproject.toml (1)

5-5: Exact Python pin may be too strict for deployability

Pinning requires-python to an exact micro version (==3.12.10) can block environments that provide 3.12.11+ security releases. Consider a compatible range:

-requires-python = "==3.12.10"
+requires-python = ">=3.12,<3.13"

If your infra tooling enforces 3.12.10 specifically (e.g., via container tags), feel free to keep it exact.

libraries/python/pyproject.toml (1)

1-4: Optional: add a build backend for non-uv environments

If anyone installs/builds this package outside uv (e.g., plain pip, IDEs, CI builders lacking uv), consider adding a PEP 517 build backend. Example with hatchling:

+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"

This won’t affect uv but improves portability.

applications/predictionengine/pyproject.toml (1)

5-5: Avoid exact patch pin for Python; use a compatible range

Exact patch pin in requires-python is brittle and may block installs in equivalent 3.12.x environments (e.g., base images differing by patch). A typical pattern is “>=3.12,<3.13”.

-requires-python = "==3.12.10"
+requires-python = ">=3.12,<3.13"

infrastructure/images.py (1)

15-17: Also validate Dockerfile presence to fail fast with actionable error

Directory existence is necessary but not sufficient. Checking for a Dockerfile avoids later opaque build errors.

     if not service_directory.exists():
         message = f"Service directory not found: {service_directory}"
         raise FileNotFoundError(message)
+
+    dockerfile = service_directory / "Dockerfile"
+    if not dockerfile.exists():
+        raise FileNotFoundError(f"Dockerfile not found: {dockerfile}")

.github/workflows/teardown_infrastructure.yaml (1)

5-5: Clarify time zone in the comment for cron

GitHub cron uses UTC. The comment currently says “EST” which is misleading during daylight savings.

-    - cron: '0 23 * * 1,2,3,4,5' # teardown at 6:00 PM EST
+    - cron: '0 23 * * 1,2,3,4,5' # 23:00 UTC (6pm ET standard time, 7pm ET daylight time)

.github/workflows/launch_infrastructure.yaml (2)

2-8: Clarify cron timezone in comment to avoid confusion

GitHub Actions cron uses UTC. The comment “8:00 AM EST” will be incorrect during daylight saving time (it’ll run 9:00 AM ET). Suggest updating the comment to explicitly note UTC.

-    - cron: '0 13 * * 1,2,3,4,5'  # launch at 8:00 AM EST
+    - cron: '0 13 * * 1,2,3,4,5'  # 13:00 UTC (8 AM ET standard time / 9 AM ET daylight time)

---

7-15: Avoid overlapping scheduled runs; add job-level concurrency and minimal permissions

Prevent concurrent “launch” jobs from stepping on each other (e.g., if a previous run overruns) and minimize token scope.

 jobs:
   launch_infrastructure:
+    permissions:
+      contents: read
     name: Launch infrastructure on weekday schedule
     runs-on: ubuntu-latest
     environment: pulumi
+    concurrency:
+      group: launch_infrastructure-${{ github.ref }}
+      cancel-in-progress: true

pyproject.toml (1)

5-5: Exact Python version pin reduces portability

requires-python ==3.12.10 is extremely strict. Unless you require that exact patch version, consider a compatible range (e.g., >=3.12,<3.13) to ease local/CI/environment differences.

-requires-python = "==3.12.10"
+requires-python = ">=3.12,<3.13"

libraries/python/src/internal/loss_functions.py (1)

16-28: Optional: Vectorize across quantiles to reduce Python overhead

You can compute the loss for all quantiles in one pass by broadcasting targets and quantiles; this is simpler and faster.

-    errors_total = Tensor.zeros((1,))
-    for index, quantile in enumerate(quantiles):
-        error = targets.sub(predictions[:, :, index])
-        quantile_tensor = Tensor([quantile])
-        errors_total = errors_total.add(
-            Tensor.where(
-                error > 0,
-                quantile_tensor.mul(error),
-                (quantile_tensor.sub(1)).mul(error),
-            ).mean()
-        )
-
-    return errors_total.div(len(quantiles))  # shape: (1,)
+    # Broadcast targets to (B, O, K) and quantiles to (1, 1, K)
+    errors = targets[:, :, None].sub(predictions)
+    q = Tensor(quantiles)[None, None, :]
+    losses = Tensor.where(errors > 0, q.mul(errors), (q.sub(1)).mul(errors))
+    # Mean over batch and output dims, then average over quantiles
+    return losses.mean(axis=(0, 1)).mean(keepdims=True)  # shape: (1,)

libraries/python/tests/test_loss_functions.py (1)

32-39: Strengthen assertion for perfect prediction

For zero error, quantile loss should be exactly 0 within numerical tolerance. Tighten the check to assert near-zero.

-    assert loss.numpy() >= 0.0
+    assert abs(float(loss.numpy())) < 1e-6

applications/positionmanager/src/positionmanager/clients.py (3)

120-123: Prefer using DateRange.to_object() for consistency and encapsulation

You already expose a helper to serialize DateRange; use it to avoid duplication and future drift.

-        params = {
-            "start_date": date_range.start.isoformat(),
-            "end_date": date_range.end.isoformat(),
-        }
+        params = date_range.to_object()

---

126-139: HTTP ergonomics: use raise_for_status and explicit Accept header (optional)

• You can lean on response.raise_for_status() for non-204 cases to simplify error handling.
• If the service returns Arrow stream, advertise it explicitly to guard against content-type drift.

-        try:
-            response = requests.get(endpoint, params=params, timeout=30)
+        headers = {"Accept": "application/vnd.apache.arrow.stream"}
+        try:
+            response = requests.get(endpoint, params=params, headers=headers, timeout=(5, 30))
         except requests.RequestException as err:
             message = f"Data manager service call error: {err}"
             raise RuntimeError(message) from err
 
         if response.status_code == requests.codes["no_content"]:
             return pl.DataFrame()
-        if response.status_code != requests.codes["ok"]:
-            message = f"Data service error: {response.text}, status code: {response.status_code}"  # noqa: E501
-            raise requests.HTTPError(
-                message,
-                response=response,
-            )
+        response.raise_for_status()

---

144-154: Minor: avoid redundant DataFrame wrapping and favor simpler conversion

pl.from_arrow already returns a Polars DataFrame; no need to re-wrap.

-        data = pl.DataFrame(pl.from_arrow(table))
+        data = pl.from_arrow(table)
 
         data = data.with_columns(
             pl.col("datetime").cast(pl.Datetime).dt.date().alias("date")
         )

libraries/python/src/internal/cloud_event.py (1)

12-21: Optional: accept timezone as a parameter for consistency in non-ET contexts

If these helpers are used outside ET, hardcoding America/New_York can be surprising. Consider adding an optional tz parameter defaulting to ET.

I can draft a small refactor to thread an optional tz: ZoneInfo | None parameter if you want to make this configurable.

Also applies to: 29-38

applications/models/pyproject.toml (2)

5-5: Consider broadening requires-python to allow patch updates

Pinning to an exact patch version (==3.12.10) can cause churn and friction in CI images. Unless there’s a known incompatibility, prefer a compatible range like >=3.12,<3.13.

Apply this diff:

-requires-python = "==3.12.10"
+requires-python = ">=3.12,<3.13"

---

8-9: Avoid explicitly depending on botocore alongside boto3

boto3 manages its botocore pin. Declaring both can create resolver conflicts. Remove botocore unless you truly use it directly.

Apply this diff:

-    "botocore>=1.38.23",

applications/models/src/models/get_alpaca_equity_bars.py (1)

55-72: Defensive parsing: optional fields may be missing in bars

vw can be missing; using direct indexing can raise KeyError. Prefer .get with default None.

Apply this diff:

-                "volume_weighted_average_price": bar["vw"],
+                "volume_weighted_average_price": bar.get("vw"),

libraries/python/src/internal/lstm_network.py (1)

24-30: Avoid shadowing the input_size parameter inside the layer loop

Shadowing makes the code harder to read. Use a local name for the per-layer input size.

Apply this diff:

-        for index in range(layer_count):
-            input_size = input_size if index == 0 else self.hidden_size
+        for index in range(layer_count):
+            layer_input_size = input_size if index == 0 else self.hidden_size
             self.layers.append(
                 LSTMCell(
-                    input_size=input_size,
+                    input_size=layer_input_size,
                     hidden_size=self.hidden_size,
                 )
             )

libraries/python/tests/test_lstm_network.py (1)

12-17: Verify the minimum layer_count enforcement in LSTM class.

The test correctly initializes LSTM with layer_count=3, which aligns with the internal implementation that enforces a minimum of 3 layers. The test should also verify that attempting to initialize with fewer layers raises a ValueError.

Would you like me to generate an additional test case to verify that the LSTM class properly enforces the minimum layer count requirement?

libraries/python/src/internal/dataset.py (2)

10-26: Add type hints for Scaler attributes.

The Scaler class is missing type hints for its attributes means and standard_deviations. Consider adding them for better type safety.

 class Scaler:
     def __init__(self) -> None:
-        pass
+        self.means: pl.DataFrame | None = None
+        self.standard_deviations: pl.DataFrame | None = None

---

116-117: Avoid using boolean literals with noqa comments.

The code uses # noqa: FBT003 to suppress linting warnings about boolean literals. Consider using variables for better readability.

+        holiday_true = True
+        holiday_false = False
         data = (
             data.with_columns(
                 pl.col("datetime").dt.weekday().alias("temporary_weekday")
             )
             .with_columns(
                 pl.when(
                     pl.col("is_holiday").is_null()
                     & (pl.col("temporary_weekday") <= friday_number)
                 )
-                .then(True)  # noqa: FBT003
+                .then(holiday_true)
                 .when(
                     pl.col("is_holiday").is_null()
                     & (pl.col("temporary_weekday") > friday_number)
                 )
-                .then(False)  # noqa: FBT003
+                .then(holiday_false)

Also applies to: 121-122

libraries/python/tests/test_dataset.py (1)

81-134: Add validation for missing "targets" key in predict mode.

The test correctly validates batch structure for prediction mode. Consider also testing that the "targets" key is NOT present in predict mode batches, as it should only be included for train/validate modes.

     for batch in batches:
         assert "encoder_categorical_features" in batch
         assert "encoder_continuous_features" in batch
         assert "decoder_categorical_features" in batch
         assert "static_categorical_features" in batch
+        # Verify targets are not included in predict mode
+        assert "targets" not in batch

Dockerfile.tests (1)

30-30: Potentially unnecessary early copy of sources

Unless uv needs the full library source to resolve workspace/local path deps during sync, keep full libraries/ copy after uv sync to avoid cache invalidation on code-only changes.

libraries/python/tests/test_mhsa_network.py (3)

9-12: Nit: reuse variables instead of hardcoded literals

Prefer passing heads_count and embedding_size variables to avoid divergence if they change.

-    attention = MultiHeadSelfAttentionNetwork(heads_count=8, embedding_size=64)
+    attention = MultiHeadSelfAttentionNetwork(
+        heads_count=heads_count, embedding_size=embedding_size
+    )

---

31-36: Add a negative test for invalid configuration (embedding not divisible by heads)

The network should reject incompatible configurations (e.g., embedding_size not divisible by heads_count). Add a test to assert a ValueError (or the specific exception you raise).

Example test to add:

def test_multi_head_attention_invalid_heads_divisibility() -> None:
    # embedding_size=30 is not divisible by heads_count=8
    with pytest.raises(ValueError):
        _ = MultiHeadSelfAttentionNetwork(heads_count=8, embedding_size=30)

---

17-22: Optional: seed RNG for determinism (if future assertions go beyond shapes)

Currently you only assert shapes, so nondeterminism is fine. If you later assert on values, seed both numpy and tinygrad RNGs to prevent flakes.

libraries/python/src/internal/dates.py (1)

8-31: Consider Pydantic v2 serializers instead of json_encoders

In Pydantic v2, field_serializer is the preferred way to control JSON serialization. json_encoders may continue to work, but moving to serializers is more idiomatic and explicit.

Example:

 class Date(BaseModel):
@@
-    model_config = {"json_encoders": {datetime.date: lambda d: d.strftime("%Y/%m/%d")}}
+    @pydantic.field_serializer("date", when_used="json")
+    def serialize_date(self, value: datetime.date) -> str:
+        return value.strftime("%Y/%m/%d")

Note: add from pydantic import field_serializer import or reference via pydantic.field_serializer.

libraries/python/src/internal/variable_selection_network.py (1)

1-22: Confirm parameter registration and consider normalization

Short summary: tft_model assigns the two VSNs to self and calls get_parameters(self) — please verify that tinygrad.nn.state.get_parameters actually traverses object attributes and includes parameters from nested nn.Linear instances. I couldn't import tinygrad here to inspect get_parameters, so this is inconclusive from the sandbox.

Points to check:

• libraries/python/src/internal/tft_model.py
  • self.encoder_variable_selection_network = VariableSelectionNetwork(...)
  • self.decoder_variable_selection_network = VariableSelectionNetwork(...)
  • self.parameters = get_parameters(self)
    => Ensure get_parameters(self) includes parameters from those VSN attributes.
• libraries/python/src/internal/variable_selection_network.py
  • VariableSelectionNetwork.forward currently returns inputs.sigmoid() — if you want a TFT-style attention/gating across features, consider normalizing across the feature dimension (softmax) instead of per-feature sigmoid.

Suggested diff (optional — only if tinygrad.Tensor.softmax supports dim):

     def forward(self, inputs: Tensor) -> Tensor:
         inputs = self.input_layer(inputs)
         inputs = inputs.relu()
         inputs = self.output_layer(inputs)
-        return inputs.sigmoid()
+        # Normalize across the feature dimension for simplex-style weights
+        return inputs.softmax(dim=-1)  # verify tinygrad's softmax signature

Quick local verification you can run:

• Inspect get_parameters source in your environment:
  python - <<'PY'
  import inspect, tinygrad.nn.state as s
  print(inspect.getsource(s.get_parameters))
  PY
• Or check whether get_parameters(self) actually contains parameters from self.encoder_variable_selection_network and self.decoder_variable_selection_network at runtime.

If get_parameters does not collect nested attributes, explicitly aggregate VSN parameters (e.g., extend the parameter list with get_parameters(self.encoder_variable_selection_network) and get_parameters(self.decoder_variable_selection_network)).

applications/datamanager/tests/test_datamanager_main.py (2)

21-33: Replacements from SummaryDate to Date are correct; add a JSON serialization test to preserve behavior

The basics are covered. Add a test to ensure the JSON encoder for Date still outputs YYYY/MM/DD as previously asserted for SummaryDate.

Example:

def test_date_json_encoder() -> None:
    d = Date(date=date(2023, 5, 15))
    json_data = d.model_dump(mode="json")
    assert json_data["date"] == "2023/05/15"

---

156-175: S3Client patching OK; consider adding a test for empty key listing vs missing path semantics

You handle the "not found" case where list_objects returns empty. Consider also testing when data_bucket_name or the path prefix is misconfigured to ensure the endpoint fails fast with a clear error.

libraries/python/tests/test_equity_bar.py (2)

133-146: Align test name with behavior: pass a string to exercise the timestamp parser

The test name says “string iso format” but the test passes a date object. Pass a string to cover the validator’s string parsing path.

Apply this diff:

-    equity_bar = EquityBar(
-        ticker="AAPL",
-        timestamp=date.fromisoformat("2023-06-15"),
+    equity_bar = EquityBar(
+        ticker="AAPL",
+        timestamp="2023-06-15",
         open_price=150.0,
         high_price=155.0,
         low_price=149.0,
         close_price=153.0,
         volume=1000000,
         volume_weighted_average_price=152.5,
     )

---

67-81: Message substring assertions look good; consider adding a malformed-date test

Asserting substrings keeps this resilient to Pydantic’s error wrappers. Consider adding a test that an invalid date string raises with the expected message to fully cover validate_timestamp.

Example to add elsewhere in this file:

def test_equity_bar_invalid_timestamp_string() -> None:
    with pytest.raises(ValidationError) as exc_info:
        EquityBar(
            ticker="AAPL",
            timestamp="2023/15/01",  # invalid format for the model
            open_price=150.0,
            high_price=155.0,
            low_price=149.0,
            close_price=153.0,
            volume=1000000,
            volume_weighted_average_price=152.5,
        )
    assert "Invalid date format" in str(exc_info.value)

libraries/python/tests/test_dates.py (1)

29-33: Use a string input to cover the string-parsing path (test name says “string”)

This test currently passes a date object. Pass a string to match the name and to exercise the format parsing logic.

Apply this diff:

-def test_date_string_dash_format() -> None:
-    date_instance = Date(date=datetime.date.fromisoformat("2023-03-15"))
+def test_date_string_dash_format() -> None:
+    date_instance = Date(date="2023-03-15")  # type: ignore

libraries/python/src/internal/mhsa_network.py (1)

61-64: Optional: expose a training flag to control dropout

Consider a self.training flag (and/or a forward arg) to toggle dropout deterministically in tests/inference without changing the rate.

I can sketch a minimal training/eval toggle if you want it in this PR.

libraries/python/tests/test_variable_selection_network.py (2)

6-7: Seed RNG for determinism across runs

Seeding avoids sporadic failures in environments that analyze exact numeric thresholds or aggregate stats.

Apply this diff:

-rng = Generator(PCG64())
+rng = Generator(PCG64(0))

---

18-23: Weight-shape assertions may be brittle against tinygrad changes

tinygrad.nn.Linear’s internal weight layout can vary between (out, in) and (in, out) across versions. These checks may break on upgrades.

Consider replacing weight-shape assertions with behavioral checks (e.g., feed (B, input_dimension) and assert output shape is (B, input_dimension), which you already do below), or gate these asserts behind a detected layout:

# example approach (no diff applied):
wshape = vsn.input_layer.weight.shape
assert input_dimension in wshape and hidden_size in wshape

Would you like me to adjust the tests to be layout-agnostic?

applications/datamanager/src/datamanager/main.py (2)

255-261: Avoid overriding CloudEvent helper’s timestamp; remove duplicate “date”.

create_cloud_event_success already injects a timestamp in data. Passing your own date key overrides it. If overriding is not intentional, drop the custom date field for consistency.

Apply this diff:

-        data={
-            "date": request_fetch_date,
-            "count": count,
-        },
+        data={"count": count},

---

294-333: Prefer specific exception handling for calendar endpoint.

Catching bare Exception hides actionable errors (API/HTTP/validation) and makes observability harder. Handle known exceptions and return 500 with clearer messages.

Apply this diff:

-    except Exception as e:  # noqa: BLE001
+    except (requests.RequestException, Exception) as e:  # replace Exception with specific Alpaca exceptions if available
         logger.error(f"Error fetching calendar data: {e}")
         logger.error(traceback.format_exc())
         return Response(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             content=json.dumps({"error": f"Failed to fetch calendar data: {e!s}"}),
             media_type="application/json",
         )

applications/positionmanager/tests/test_positionmanager_main.py (1)

21-24: Patch target for requests.get is unnecessary here.

DataClient.get_data is already mocked, so requests.get inside the client won’t be called. This patch can be removed to reduce noise.

Apply this diff:

-    @patch("applications.positionmanager.src.positionmanager.main.requests.get")
     def test_open_position_success(
         self,
-        mock_requests_get: MagicMock,
         MockDataClient: MagicMock,  # noqa: N803
         MockAlpacaClient: MagicMock,  # noqa: N803
     ) -> None:

libraries/python/src/internal/equity_bar.py (1)

40-49: Accepting only YYYY-MM-DD strings is fine; mention it in the field description or reuse internal Date parser.

Current validator is strict ISO date. If you want to accept “YYYY/MM/DD” like internal.Date, reuse that parser for consistency; otherwise, clarify the format in the docstring.

Apply this diff to clarify the description:

-    timestamp: date = Field(..., description="The date of the bar in YYYY-MM-DD format")
+    timestamp: date = Field(..., description="The date of the bar in YYYY-MM-DD format (ISO 8601)")

applications/models/src/models/train_tft_model.py (1)

143-165: Hard-coded training CSV path; consider parameterizing for portability.

Embedding a repo-relative path reduces reusability in Flyte. Expose filepath as a workflow input or env var.

Apply this diff to accept a filepath:

-@workflow
-def train_tft_model() -> None:
-    dataset = read_local_data(
-        filepath="applications/models/src/models/training_data.csv"
-    )  # type: ignore[assignment]
+@workflow
+def train_tft_model(filepath: str = "applications/models/src/models/training_data.csv") -> None:
+    dataset = read_local_data(filepath=filepath)  # type: ignore[assignment]

applications/positionmanager/src/positionmanager/main.py (1)

245-256: Avoid duplicating timestamp field; create_cloud_event_success already adds one.

Remove redundant "date" key from data to keep payloads consistent across apps.

Apply this diff:

     return create_cloud_event_success(
         application_name="positionmanager",
         event_metadata=["positions", "open"],
         data={
-            "date": date_range.end.isoformat(),
             "initial_cash_balance": float(cash_balance),
             "final_cash_balance": float(final_cash_balance),
             "optimized_portfolio": optimized_portfolio,
             "executed_trades": executed_trades,
             "time_period": date_range.to_object(),
         },
     )

libraries/python/src/internal/tft_model.py (2)

85-90: Nit: parameter naming (attention_head_size)

This parameter represents a count, not a size. Consider renaming to attention_head_count in Parameters and here for clarity and consistency with MultiHeadSelfAttentionNetwork(heads_count=...). This is a naming-only suggestion; not a functional issue.

---

247-260: State serialization LGTM

The save/load APIs are consistent with tinygrad’s state utils. Optional: check return value of load_state_dict for diagnostics.

If desired, capture and log the return for visibility:

-        states = safe_load(path_and_file)
-        load_state_dict(self, states)
+        states = safe_load(path_and_file)
+        _ = load_state_dict(self, states)

infrastructure/environment_variables.py (1)

20-32: Preserve secret semantics and add a temporary alias for backward compatibility.

Wrap the final mapping in Output.secret to ensure the entire map is treated as a secret and not logged. Also add ALPACA_API_KEY as an alias to reduce rollout risk; you can remove it after all consumers migrate.

-    return pulumi.Output.all(
-        [
-            ("ALPACA_API_KEY_ID", alpaca_api_key_id),
-            ("ALPACA_API_SECRET", alpaca_api_secret),
-            ("DATA_BUCKET_NAME", data_bucket_name),
-            ("POLYGON_API_KEY", polygon_api_key),
-            ("DUCKDB_ACCESS_KEY", duckdb_access_key),
-            ("DUCKDB_SECRET", duckdb_secret),
-            ("AWS_REGION", aws_region),
-            ("DUCKDB_USER_ACCESS_KEY_ID", duckdb_user_access_key.id),
-            ("DUCKDB_USER_ACCESS_KEY_SECRET", duckdb_user_access_key.secret),
-        ]
-    ).apply(lambda secrets: dict(secrets))
+    return pulumi.Output.secret(
+        pulumi.Output.all(
+            [
+                ("ALPACA_API_KEY_ID", alpaca_api_key_id),
+                # Temporary alias to ease migration; remove after downstream updates.
+                ("ALPACA_API_KEY", alpaca_api_key_id),
+                ("ALPACA_API_SECRET", alpaca_api_secret),
+                ("DATA_BUCKET_NAME", data_bucket_name),
+                ("POLYGON_API_KEY", polygon_api_key),
+                ("DUCKDB_ACCESS_KEY", duckdb_access_key),
+                ("DUCKDB_SECRET", duckdb_secret),
+                ("AWS_REGION", aws_region),
+                ("DUCKDB_USER_ACCESS_KEY_ID", duckdb_user_access_key.id),
+                ("DUCKDB_USER_ACCESS_KEY_SECRET", duckdb_user_access_key.secret),
+            ]
+        ).apply(lambda secrets: dict(secrets))
+    )

applications/datamanager/pyproject.toml (1)

6-19: Action: Add alpaca-py to applications/datamanager/pyproject.toml

datamanager imports alpaca.trading (applications/datamanager/src/datamanager/clients.py) but applications/datamanager/pyproject.toml doesn't declare alpaca-py — this will raise ImportError at runtime. I verified the repo already declares alpaca-py in applications/positionmanager/pyproject.toml ("alpaca-py>=0.15.0") and uv.lock pins alpaca-py to 0.42.0; pick the repo-wide constraint you prefer.

Files to update:

• applications/datamanager/pyproject.toml — add dependency
• applications/datamanager/src/datamanager/clients.py — (imports alpaca.trading)

Suggested diff (align version with positionmanager or uv.lock as desired):

 dependencies = [
   "fastapi>=0.115.12",
   "uvicorn>=0.34.2",
   "duckdb>=1.2.2",
   "polars>=1.29.0",
   "pyarrow>=20.0.0",
   "loguru>=0.7.3",
   "requests>=2.31.0",
   "prometheus-fastapi-instrumentator>=7.1.0",
   "cloudevents>=1.12.0",
   "polygon-api-client>=1.14.6",
   "boto3>=1.38.23",
+  "alpaca-py>=0.15.0",
   "internal==0.1.0",
 ]

libraries/python/src/internal/dates.py (1)

38-49: Fix validator type annotations and avoid redundant @classmethod.

The end validator is declared on a date field but typed as datetime.datetime. Also, field_validator returns a classmethod in Pydantic v2; the explicit @classmethod is redundant and unconventional.

Apply:

-    @field_validator("end")
-    @classmethod
-    def check_end_after_start(
-        cls,
-        end_value: datetime.datetime,
-        info: core_schema.ValidationInfo,
-    ) -> datetime.datetime:
+    @field_validator("end")
+    def check_end_after_start(
+        cls,
+        end_value: datetime.date,
+        info: core_schema.ValidationInfo,
+    ) -> datetime.date:
         start_value = info.data.get("start")
         if start_value and end_value <= start_value:
             msg = "End date must be after start date."
             raise ValueError(msg)
         return end_value

pyproject.toml (1)

22-28: Pytest rootdir points to an absolute path that likely doesn't exist

"--rootdir=/tests" will set the repository root for pytest to a non-existent absolute directory on most CI/dev setups, breaking discovery/imports. You already set testpaths; remove rootdir to let pytest infer the correct project root.

 addopts = [
     "--verbose",
     "--tb=short",
     "--strict-markers",
     "--color=yes",
-    "--rootdir=/tests",
 ]

libraries/python/src/internal/lstm_network.py (1)

68-72: Dropout is applied to the wrong tensor and toggles training mode unexpectedly

• Dropout should be applied to the layer’s output (layer_hidden_state), not directly to hidden_state[index] after it’s stored.
• Calling .train() on a Tensor here is surprising and leaves training state altered for downstream ops.

Refactor to apply dropout to layer_hidden_state without mutating training mode.

-                if self.dropout_rate > 0.0 and index < self.layer_count - 1:
-                    hidden_state[index].train()
-                    hidden_state[index] = hidden_state[index].dropout(self.dropout_rate)
+                if self.dropout_rate > 0.0 and index < self.layer_count - 1:
+                    layer_hidden_state = layer_hidden_state.dropout(self.dropout_rate)
+
+                # propagate the (possibly dropped-out) hidden state forward and into states
+                hidden_state[index] = layer_hidden_state
+                cell_state[index] = layer_cell_state

Note: This moves state assignment after optional dropout to keep state and forward input consistent.

Also applies to: 56-66

applications/datamanager/src/datamanager/main.py (1)

179-185: Fix Content-Disposition header and Arrow media type

• f-string debug syntax {filename=} yields Content-Disposition: attachment; filename='…' which is invalid.
• You’re writing Arrow IPC stream (RecordBatchStreamWriter), so media type should be application/vnd.apache.arrow.stream.

Apply this patch:

-            filename = f"equity_bars_{start_date}_{end_date}.arrow"
-            content_disposition = f"attachment; {filename=}"
+            filename = f"equity_bars_{start_date}_{end_date}.arrow"
+            content_disposition = f'attachment; filename="{filename}"'
 ...
-        return Response(
+        return Response(
             content=sink.getvalue().to_pybytes(),
-            media_type="application/vnd.apache.arrow.file",
+            media_type="application/vnd.apache.arrow.stream",
             headers={
                 "Content-Disposition": content_disposition,
                 "X-Row-Count": str(data.num_rows),
                 "X-Start-Date": str(start_date),
                 "X-End-Date": str(end_date),
             },
         )

applications/positionmanager/pyproject.toml (1)

5-5: Python pin (==3.12.10) conflicts with test image (Python 3.13) — fix required

Short: Multiple pyproject.toml files (and uv.lock) pin requires-python = "==3.12.10", while the test images use Python 3.13 — this will cause lock/uv resolution failures in CI/tests.

Files to update / check:

• pyproject.toml (root) — requires-python = "==3.12.10"
• libraries/python/pyproject.toml — requires-python = "==3.12.10"
• applications/positionmanager/pyproject.toml — requires-python = "==3.12.10"
• applications/predictionengine/pyproject.toml — requires-python = "==3.12.10"
• applications/datamanager/pyproject.toml — requires-python = "==3.12.10"
• applications/models/pyproject.toml — requires-python = "==3.12.10"
• infrastructure/pyproject.toml — requires-python = "==3.12.10"
• uv.lock — requires-python = "==3.12.10" (must be regenerated after changes)
• Dockerfiles using Python 3.13:
  • Dockerfile.tests (root): FROM python:3.13
  • applications/datamanager/Dockerfile.test: FROM python:3.13-slim

Proposed change (preferred):
requires-python = ">=3.12,<3.14"

After making the pin change in all pyproject.toml files, regenerate the lockfile (e.g., run the project’s uv sync command used in Dockerfile.tests) and re-run tests.

Alternative: align test images to Python 3.12.10 (change Dockerfile.tests and any test images) instead of loosening the pyproject pins.

applications/models/pyproject.toml (1)

7-19: Remove duplicate internal dependency; consider relying on the workspace source.

The dependency "internal==0.1.0" is listed twice, which can cause resolver noise. Also, since you’ve configured [tool.uv.sources] to use the workspace, you can avoid pinning or relax to a range to prevent version skew between the workspace and this app.

Apply this minimal fix:

 dependencies = [
-    "internal==0.1.0",
+    "internal==0.1.0",
     "boto3>=1.38.23",
     "botocore>=1.38.23",
     "requests>=2.31.0",
     "pyarrow>=20.0.0",
     "polygon-api-client>=1.14.6",
-    "internal==0.1.0",
     "flytekit>=1.16.1",
     "polars>=1.29.0",
     "loguru>=0.7.3",
     "pydantic>=2.8.2",
     "wandb>=0.21.1",
 ]

Optional follow-ups:

• Prefer unpinned internal to align with the workspace source:
  • Replace "internal==0.1.0" with "internal" or "internal>=0.1.0".
• Consider relaxing requires-python to a minor range (e.g., ">=3.12,<3.13") unless you have a strict patch-level constraint.

libraries/python/src/internal/loss_functions.py (1)

16-26: Bug: accumulation doesn’t update errors_total (non-inplace add).

Tensor.add likely returns a new Tensor; the current code discards the result, yielding an incorrect (always-zero) loss.

Apply this fix:

-    errors_total = Tensor.zeros((1,))
+    errors_total = Tensor.zeros((1,))
     for index, quantile in enumerate(quantiles):
         error = targets.sub(predictions[:, :, index])
         quantile_tensor = Tensor([quantile])
-        errors_total.add(
+        errors_total = errors_total.add(
             Tensor.where(
                 error > 0,
                 quantile_tensor.mul(error),
                 (quantile_tensor.sub(1)).mul(error),
             ).mean()
         )

libraries/python/src/internal/lstm_network.py (1)

76-81: Stacking outputs will fail/behave oddly for a single timestep; handle len==1 safely

Using Tensor.stack(outputs[0], *outputs[1:], dim=1) assumes ≥1 outputs and relies on tinygrad’s varargs semantics; single-element behavior can be inconsistent and the current pattern is brittle. Stack from the whole list and special-case len==1 to unsqueeze.

-        output_tensor = Tensor.stack(outputs[0], *outputs[1:], dim=1)
+        if len(outputs) == 1:
+            output_tensor = outputs[0].unsqueeze(dim=1)
+        else:
+            output_tensor = Tensor.stack(*outputs, dim=1)

applications/datamanager/src/datamanager/main.py (1)

266-281: Don’t return 404 on S3 listing exceptions; distinguish errors from “not found”

An exception while listing objects is an operational error (500), not a “no data” condition (404). Only return 404 when the list is empty without exceptions.

-    try:
-        blobs = list(s3_client.list_objects(prefix=prefix))
-    except Exception as e:  # noqa: BLE001
-        logger.error(f"Error listing S3 objects: {e}")
-        return Response(
-            status_code=status.HTTP_404_NOT_FOUND,
-            content=json.dumps({"error": "No equity bars found"}),
-            media_type="application/json",
-        )
+    try:
+        blobs = list(s3_client.list_objects(prefix=prefix))
+    except Exception as e:  # noqa: BLE001
+        logger.error(f"Error listing S3 objects: {e}")
+        return Response(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=json.dumps({"error": f"Failed to list equity bars: {e!s}"}),
+            media_type="application/json",
+        )

Optionally catch boto3’s ClientError explicitly if available.

.gitignore (1)

6-8: Scope CSV and wandb ignores to avoid masking legitimate data files.

Top-level ignores for *.csv and wandb/ can inadvertently hide intentionally tracked assets elsewhere in the repo. Recommend scoping to the models app (or a dedicated data/output directory) to prevent accidental omissions.

Apply this diff to narrow the patterns:

-*.egg-info
-wandb/
-*.csv
+*.egg-info
+# Scope experiment artifacts to models app only (adjust as needed)
+applications/models/wandb/
+applications/models/**/*.csv

Optional:

• If you want to allow CSVs in repo-wide docs/examples, consider adding exceptions with negate patterns (!docs/**/*.csv).

Also applies to: 10-10, 19-21

applications/datamanager/pyproject.toml (1)

18-18: Avoid hard pinning the internal workspace dependency to reduce churn.

You’re already sourcing internal from the uv workspace; pinning to an exact version adds friction when you bump the library.

Apply one of the following:

• Prefer letting the workspace source define the version:

-    "internal==0.1.0",
+    "internal",

• Or allow forward-compatible bumps:

-    "internal==0.1.0",
+    "internal>=0.1.0",

libraries/python/src/internal/dates.py (1)

8-31: Date model looks good — add backward-compatibility alias (SummaryDate → Date)

Renaming SummaryDate → Date is a breaking change. I searched the repo for "SummaryDate" (no matches found), but absence of matches here doesn't guarantee no external consumers — add a soft-landing alias if downstream code may reference the old name.

• File to update:
  • libraries/python/src/internal/dates.py — add alias at the bottom of the module

Suggested diff:

+# Backward-compatibility alias (remove after migration)
+SummaryDate = Date

libraries/python/pyproject.toml (1)

1-12: Right direction for a shared internal library; consider optionalizing heavy deps.

This centralizes shared code under uv. To reduce install footprint for services not using ML, consider moving tinygrad (and possibly numpy) under an optional dependency group, e.g., [project.optional-dependencies]. Keep pydantic, cloudevents, polars as core if widely used.

Example:

 [project]
 name = "internal"
 version = "0.1.0"
 description = "Shared Python resources"
 requires-python = "==3.12.10"
-dependencies = [
-    "pydantic>=2.8.2",
-    "cloudevents>=1.12.0",
-    "tinygrad>=0.10.3",
-    "numpy>=2.2.6",
-    "polars>=1.29.0",
-]
+dependencies = [
+    "pydantic>=2.8.2",
+    "cloudevents>=1.12.0",
+    "polars>=1.29.0",
+]
+
+[project.optional-dependencies]
+ml = [
+    "numpy>=2.2.6",
+    "tinygrad>=0.10.3",
+]

If you make this change, ensure packages that require ML features add internal[ml] to their dependencies.

.github/workflows/teardown_infrastructure.yaml (1)

1-9: Clarify the schedule comment for DST and simplify the if guard (optional).

• The comment says “6:00 PM EST,” but 23:00 UTC is 7:00 PM during EDT. Prefer “ET” or specify both.
• The if condition is redundant for a workflow that only has a single schedule; it’s harmless but can be removed.

Apply:

 name: Teardown infrastructure
 on:
   schedule:
-    - cron: '0 23 * * 1,2,3,4,5' # teardown at 6:00 PM EST
+    - cron: '0 23 * * 1,2,3,4,5' # 23:00 UTC (6pm ET standard / 7pm EDT)
 jobs:
   teardown_infrastructure:
-    name: Teardown infrastructure on weekday schedule
-    if: github.event.schedule == '0 23 * * 1,2,3,4,5'
+    name: Teardown infrastructure on weekday schedule

.github/workflows/launch_infrastructure.yaml (1)

2-8: Cron comment references EST; consider DST implications.

The cron at Line 5 runs at 13:00 UTC, which is 8:00 AM EST but 9:00 AM EDT. If you intend 8:00 AM local ET year-round, update the comment and/or cron strategy to avoid confusion.

libraries/python/tests/test_lstm_network.py (1)

39-47: Strengthen state validation in tests.

Optionally assert that each state list matches layer_count to catch regressions (e.g., hidden/cell state list length).

You can extend assertions like this:

-    assert isinstance(hidden_state, tuple)
-    assert len(hidden_state) == expected_hidden_state
+    assert isinstance(hidden_state, tuple)
+    assert len(hidden_state) == expected_hidden_state  # (hidden_state, cell_state)
+    hs, cs = hidden_state
+    assert isinstance(hs, list) and isinstance(cs, list)
+    assert len(hs) == lstm.layer_count
+    assert len(cs) == lstm.layer_count

Also applies to: 72-77, 87-91, 103-108

applications/models/src/models/get_alpaca_calendar.py (1)

33-37: Optional: allow output path override (CLI arg or env).

Hard-coding "calendar.csv" to CWD can be inconvenient in CI or when organizing datasets.

Example: accept an OUTPUT_PATH env var with a default.

-    calendar_data.write_csv("calendar.csv")
+    output_path = os.getenv("OUTPUT_PATH", "calendar.csv")
+    calendar_data.write_csv(output_path)
-    logger.info("Calendar data has been written to calendar.csv")
+    logger.info(f"Calendar data has been written to {output_path}")

libraries/python/src/internal/cloud_event.py (1)

7-11: Type generality and docstrings for maintainability.

Consider using Sequence[str] for event_metadata and add short docstrings clarifying attribute/type composition and timezone choice.

Also applies to: 24-28

libraries/python/src/internal/loss_functions.py (1)

16-28: Optional: vectorize across quantiles to reduce Python loop overhead.

You can stack quantiles into a Tensor and compute the piecewise loss in one pass.

Sketch:

# q: (Q,), error: (B, O, Q)
q = Tensor(quantiles)
error = targets.unsqueeze(-1).sub(predictions)
loss_q = Tensor.where(error > 0, q * error, (q - 1) * error).mean(axis=(0, 1))  # (Q,)
return loss_q.mean().reshape((1,))

libraries/python/src/internal/variable_selection_network.py (2)

1-2: Unify tinygrad imports for consistency with other internal modules

Other internal modules (e.g., mhsa_network.py) import Linear directly from tinygrad.nn. Consider aligning import style here to avoid mixing patterns across the codebase.

-from tinygrad import nn
-from tinygrad.tensor import Tensor
+from tinygrad.nn import Linear
+from tinygrad.tensor import Tensor

---

17-21: Add a runtime shape check and minimal docstring

Shape mismatches can propagate and be hard to debug later. A fast check keeps failures local. Adding a short docstring clarifies expected input/output shapes.

-    def forward(self, inputs: Tensor) -> Tensor:
+    def forward(self, inputs: Tensor) -> Tensor:
+        """
+        Args:
+            inputs: Tensor of shape (..., input_dimension)
+        Returns:
+            Tensor of shape (..., input_dimension) with values in [0, 1]
+        """
+        # Quick runtime validation
+        if inputs.shape[-1] != self.input_dimension:
+            raise ValueError(
+                f"Expected inputs.shape[-1] == {self.input_dimension}, got {inputs.shape[-1]}"
+            )
         inputs = self.input_layer(inputs)
         inputs = inputs.relu()
         inputs = self.output_layer(inputs)
         return inputs.sigmoid()

libraries/python/tests/test_mhsa_network.py (3)

8-15: Add a negative-case test for non-divisible head dimensions

This guards the constructor validation.

 def test_multi_head_attention_initialization() -> None:
     heads_count = 8
     embedding_size = 64
     attention = MultiHeadSelfAttentionNetwork(heads_count=8, embedding_size=64)
 
     assert attention.heads_count == heads_count
     assert attention.embedding_size == embedding_size
+
+
+def test_multi_head_attention_invalid_dims_raises() -> None:
+    # 30 is not divisible by 8
+    try:
+        _ = MultiHeadSelfAttentionNetwork(heads_count=8, embedding_size=30)
+        assert False, "Expected ValueError for invalid heads/embedding ratio"
+    except ValueError:
+        pass

---

17-29: Assert attention weights normalization across key dimension

Validates the softmax property: sums should be ~1 across the last axis.

 def test_multi_head_attention_forward() -> None:
     attention = MultiHeadSelfAttentionNetwork(heads_count=4, embedding_size=32)
 
     input_tensor = Tensor(rng.standard_normal((2, 10, 32)))
     output, attention_weights = attention.forward(input_tensor)
 
     batch_size = 2
     heads_count = 4
 
     assert output.shape == (batch_size, 10, 32)
     assert attention_weights.shape[0] == batch_size
     assert attention_weights.shape[1] == heads_count
+    # Softmax normalization: sum over keys dimension (-1) ≈ 1
+    sums = attention_weights.sum(axis=-1).numpy()
+    assert (abs(sums - 1.0) < 1e-5).all()

---

64-73: Exercise dropout path without changing shapes

A simple sanity check that enabling dropout preserves shapes and runs without error.

 def test_multi_head_attention_batch_processing() -> None:
     attention = MultiHeadSelfAttentionNetwork(heads_count=2, embedding_size=32)
 
     for batch_size in [1, 2, 4, 8]:
         input_tensor = Tensor(rng.standard_normal((batch_size, 5, 32)))
         output, attention_weights = attention.forward(input_tensor)
 
         assert output.shape == (batch_size, 5, 32)
         assert attention_weights.shape[0] == batch_size
+
+
+def test_multi_head_attention_dropout_shapes() -> None:
+    attention = MultiHeadSelfAttentionNetwork(heads_count=2, embedding_size=32, dropout_rate=0.5)
+    input_tensor = Tensor(rng.standard_normal((2, 6, 32)))
+    output, attention_weights = attention.forward(input_tensor)
+    assert output.shape == (2, 6, 32)
+    assert attention_weights.shape[:2] == (2, 2)

applications/models/src/models/get_alpaca_equity_bars.py (2)

21-27: Use requests params rather than manual query construction

requests will handle encoding and edge cases for you; also use headers per-call to ensure validation is performed.

-    response = requests.get(url, headers=headers, timeout=30)
+    response = requests.get(url, headers=_alpaca_headers(), timeout=30)

---

80-85: Prefer UTC internally; only localize if needed for logging

Using NY time to compute a 6-year window is okay, but it can lead to the 'Z' bug above and DST edge conditions. Consider computing in UTC and converting only when necessary for human-oriented reporting.

-    end = datetime.now(tz=ZoneInfo("America/New_York"))
+    end = datetime.now(tz=ZoneInfo("UTC"))
     start = end - timedelta(days=365 * 6)

libraries/python/src/internal/lstm_network.py (1)

32-38: Add basic input validation for forward()

Forward assumes a 3D input (batch, time, features). Add a quick shape check and explicit int cast for sequence_length for clarity.

     def forward(
         self,
-        inputs: Tensor,
+        inputs: Tensor,
         state: tuple[list[Tensor], list[Tensor]] | None = None,
     ) -> tuple[Tensor, tuple[list[Tensor], list[Tensor]]]:
-        batch_size, sequence_length, _ = inputs.shape
+        if len(inputs.shape) != 3:
+            raise ValueError(f"Expected inputs with shape (batch, time, features), got {inputs.shape}")
+        batch_size, sequence_length, _ = inputs.shape
+        sequence_length = int(sequence_length)

Also applies to: 39-50, 53-55

.mise.toml (2)

44-50: Make port mapping configurable; avoid hard-coding 8080

Parameterize host/container ports to avoid collisions and allow non-8080 services.

 [tasks."application:service:run:production"]
 description = "Run the service application"
 run = """
 docker run \
 --env-file .env \
- --publish 8080:8080 \
+ --publish {{arg(name="host_port", default="8080")}}:{{arg(name="container_port", default="8080")}} \
 pocketsizefund/{{arg(name="application_name")}}:latest \
 """

---

55-57: Path updates to applications/ look good; add a unit-tests task using uv for faster local runs

The cd path changes are correct. Given our team guideline (remembered from prior feedback) to use mise tasks for tests/format/lint, consider adding a fast unit test task that runs directly with uv/pytest (complementary to the docker-based integration harness).

Suggested addition (new task):

[tasks."python:test:unit"]
description = "Run Python unit tests locally with uv/pytest"
run = """
uv run pytest -q --disable-warnings --maxfail=1
"""

Also consider a coverage variant if desired.

Also applies to: 62-64, 69-71, 76-78

applications/datamanager/src/datamanager/main.py (3)

193-205: Keep error telemetry but avoid double-logging full tracebacks

You already log the exception message and a traceback. Consider reducing to one structured log with e and traceback once to keep logs concise, or keep as-is if you rely on message + trace separation.

---

208-223: CloudEvent success payload includes a date twice; clarify intent

create_cloud_event_success injects a "date" (now) and you pass "date" (request_fetch_date). The merge order makes your provided date win, which is fine, but the implicit override is non-obvious. Either:

• remove "date" from the data payload here (let the helper set now), or
• add a different key like "requested_date" to avoid ambiguity.

-        data={
-            "date": request_fetch_date,
-            "count": count,
-        },
+        data={
+            "requested_date": request_fetch_date,
+            "count": count,
+        },

If you do want the event data's "date" to be the requested date, consider documenting that in the helper or reversing the merge order in create_cloud_event_success.

Also applies to: 255-262

---

294-333: New /calendar endpoint: consider basic validation and rate limiting

Endpoint looks good. Consider:

• Validating start_date <= end_date and max range to avoid heavy upstream calls.
• Returning an empty list (200) instead of 404 is sometimes preferable for “no results” endpoints; verify with API consumers.

Would you like me to add unit tests for this endpoint (success, empty, provider error) mirroring the equity bars suite?

applications/datamanager/tests/test_datamanager_main.py (3)

92-114: Good coverage for /equity-bars database error and empty-data paths

Mocks and assertions match endpoint behavior. Consider asserting media_type and headers on success paths in a separate test for stronger contract coverage.

Also applies to: 115-138

---

156-173: DELETE /equity-bars tests: success and not-found cases are solid

The mocks and expectations reflect the refactored Date model. If you adopt the 500-on-exception change, add a test to assert 500 for an S3 listing error.

Also applies to: 174-193

---

196-207: POST /equity-bars/fetch tests look good; consider adding /calendar tests

Add tests for:

• GET /calendar success: mock AlpacaClient.get_calendar to return data; assert 200 and JSON structure.
• GET /calendar empty: return []; assert 404 (or 200 if you change semantics).
• GET /calendar provider error: raise Exception; assert 500.

I can draft these test cases if you’d like.

Also applies to: 232-261

libraries/python/src/internal/summaries.py (1)

4-6: BarsSummary model is fine; consider tightening validation and export surface

Current implementation matches the tests (string date, int count). If you want to harden the model without changing semantics:

• Forbid unexpected fields.
• Optionally validate date strings follow YYYY-MM-DD (keeps current usage intact if consumers already use this format).

-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, field_validator
+import re
@@
 class BarsSummary(BaseModel):
-    date: str
-    count: int
+    model_config = ConfigDict(extra="forbid")
+
+    date: str
+    count: int
+
+    @field_validator("date")
+    def _validate_date_format(cls, v: str) -> str:  # noqa: N805
+        # Accept strictly YYYY-MM-DD; relax if broader formats are needed
+        if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", v):
+            raise ValueError("date must match YYYY-MM-DD")
+        return v

If you prefer not to enforce the date format yet, at least add extra="forbid" to prevent accidental fields from being accepted.

applications/positionmanager/tests/test_positionmanager_main.py (2)

46-59: Mocks for Arrow/Polars/Optimizer look correct; consider autospec for interface safety

The patch targets and order look right. To reduce brittle tests and catch interface drift, use autospec=True (where possible) and assert calls on these mocks to ensure your code exercised the expected paths.

---

71-87: Strengthen assertions to ensure side effects (order placement) occur

After the POST succeeds, assert that the optimizer and Alpaca client were actually used with expected arguments.

@@
             response = client.post("/positions/open", json=cloud_event_data)
 
         assert response.status_code == status.HTTP_200_OK
         response_data = response.json()
         assert "source" in response_data
         assert "type" in response_data
+        # Strengthen: verify business interactions occurred
+        MockPortfolioOptimizer.assert_called_once()
+        mock_optimizer_instance.get_optimized_portfolio.assert_called_once()
+        # Ensure we attempted to place orders using the computed allocation
+        assert mock_alpaca_instance.place_notional_order.call_count >= 1

libraries/python/tests/test_dataset.py (2)

49-79: Consider asserting expected dimension counts, not just presence

You can make this test more robust by checking counts match the current feature schema (helps detect accidental regressions in feature sets).

@@
     dimensions = dataset.get_dimensions()
 
-    assert "encoder_categorical_features" in dimensions
-    assert "encoder_continuous_features" in dimensions
-    assert "decoder_categorical_features" in dimensions
-    assert "decoder_continuous_features" in dimensions
-    assert "static_categorical_features" in dimensions
-    assert "static_continuous_features" in dimensions
+    assert dimensions["encoder_categorical_features"] > 0
+    assert dimensions["encoder_continuous_features"] > 0
+    assert dimensions["decoder_categorical_features"] > 0
+    assert dimensions["decoder_continuous_features"] == 0
+    assert dimensions["static_categorical_features"] > 0
+    assert dimensions["static_continuous_features"] == 0

---

81-135: LGTM: Prediction batch shape checks hit key invariants

Great coverage of encoder/decoder/static partitions and lengths.

As a follow-up, consider adding negative tests to lock error semantics:

• invalid data_type raises ValueError,
• insufficient days for requested input/output lengths raises ValueError,
• missing/extra columns raises ValueError.

Example additions (outside the selected lines):

def test_get_batches_invalid_type_raises(dataframe_factory):
    dataset = TemporalFusionTransformerDataset(data=dataframe_factory(days=3))
    with pytest.raises(ValueError):
        dataset.get_batches(data_type="oops")

def test_get_batches_insufficient_days_raises():
    data = pl.DataFrame({
        "timestamp": [1672531200000],  # single day
        "open_price": [100.0],
        "high_price": [110.0],
        "low_price": [90.0],
        "close_price": [105.0],
        "volume": [1000.0],
        "volume_weighted_average_price": [105.0],
        "ticker": ["AAPL"],
        "sector": ["Technology"],
        "industry": ["Consumer Electronics"],
        "is_holiday": [False],
    })
    dataset = TemporalFusionTransformerDataset(data=data)
    with pytest.raises(ValueError):
        dataset.get_batches(data_type="predict", input_length=2, output_length=1)

applications/positionmanager/src/positionmanager/clients.py (1)

120-123: Use DateRange.to_object() to construct request params (and avoid duplication).

You already expose a stable payload shape via DateRange.to_object(). Using it here reduces duplication and centralizes the date formatting.

-        params = {
-            "start_date": date_range.start.isoformat(),
-            "end_date": date_range.end.isoformat(),
-        }
+        params = date_range.to_object()

libraries/python/tests/test_dates.py (2)

10-19: Patch datetime with wraps to avoid over-mocking the module.

Patching the entire internal.dates.datetime module can inadvertently mock attributes used elsewhere. Using wraps=datetime preserves real behavior except for what you override, making the test more robust.

-def test_date_default() -> None:
-    with patch("internal.dates.datetime") as mock_datetime:
+def test_date_default() -> None:
+    with patch("internal.dates.datetime", wraps=datetime) as mock_datetime:
         mock_datetime.datetime.now.return_value = datetime.datetime(
             2023, 5, 15, 10, 30, 0, tzinfo=ZoneInfo("America/New_York")
         )
-        mock_datetime.date = datetime.date

---

29-33: Align test name with behavior: pass a string when testing “string dash format”.

The current test name suggests a string input, but a date object is provided. Either rename the test or pass the string.

-def test_date_string_dash_format() -> None:
-    date_instance = Date(date=datetime.date.fromisoformat("2023-03-15"))
+def test_date_string_dash_format() -> None:
+    date_instance = Date(date="2023-03-15")

libraries/python/tests/test_loss_functions.py (2)

17-19: Tighten the scalar-shape assertion.

The current shape assertion is too permissive and could mask regressions. Assert that the numpy view is a scalar or a single-element vector.

-    assert isinstance(loss, Tensor)
-    assert len(loss.shape) == 0 or loss.shape in [(), (0,), (1,)]
+    assert isinstance(loss, Tensor)
+    assert loss.numpy().shape in [(), (1,)]

---

28-30: Make shape assertion consistent and strict.

Same rationale as above.

-    assert isinstance(loss, Tensor)
-    assert len(loss.shape) == 0 or loss.shape in [(), (0,), (1,)]
+    assert isinstance(loss, Tensor)
+    assert loss.numpy().shape in [(), (1,)]

libraries/python/tests/test_variable_selection_network.py (1)

56-58: Add a finiteness check to catch NaNs/Infs.

This small assertion hardens the test against numerical issues without being brittle.

     output_numpy = output.numpy()
     assert np.all(output_numpy >= 0.0)
     assert np.all(output_numpy <= 1.0)
+    assert np.isfinite(output_numpy).all()

libraries/python/tests/test_equity_bar.py (2)

133-146: Fix mismatch between test name and input under test (pass a string, not a date).

The test is named “…_timestamp_string_iso_format” but passes a date object created via date.fromisoformat. Pass the raw string to exercise the validator’s string parsing path.

Apply this diff:

-    equity_bar = EquityBar(
-        ticker="AAPL",
-        timestamp=date.fromisoformat("2023-06-15"),
-        open_price=150.0,
-        high_price=155.0,
-        low_price=149.0,
-        close_price=153.0,
-        volume=1000000,
-        volume_weighted_average_price=152.5,
-    )
+    equity_bar = EquityBar(
+        ticker="AAPL",
+        timestamp="2023-06-15",
+        open_price=150.0,
+        high_price=155.0,
+        low_price=149.0,
+        close_price=153.0,
+        volume=1000000,
+        volume_weighted_average_price=152.5,
+    )

---

170-185: Consider adding tests for volume and VWAP non-negativity.

Volume and VWAP should never be negative in practice. The model currently doesn’t validate these. Recommend adding tests to guard these invariants; see model-side suggestion in internal/equity_bar.py.

Would you like me to add parametrized tests for negative volume/VWAP as follow-ups?

applications/datamanager/tests/test_datamanager_models.py (2)

20-23: Be explicit with zero-padded dates to avoid locale/implementation quirks.

While Python’s strptime usually accepts “2023-5-15” for "%Y-%m-%d", using “2023-05-15” ensures strict adherence to the documented format and avoids edge-case failures.

Apply this diff:

-        date_with_string = Date(date="2023-5-15")  # type: ignore
+        date_with_string = Date(date="2023-05-15")  # type: ignore

---

85-90: Confirm domain semantics for negative bar counts.

The test asserts negative counts are acceptable. If BarsSummary.count is intended to be non-negative (typical for aggregate counts), consider adding validation to forbid negatives. If negatives are used for sentinel/error values, keep as-is and document.

libraries/python/src/internal/equity_bar.py (1)

40-49: Optional: accept datetime inputs in timestamp validator.

If upstream may pass datetime (not just date or ISO strings), extend the validator to accept datetime and call .date().

Proposed snippet (outside selected range):

from datetime import date, datetime

@field_validator("timestamp", mode="before")
@classmethod
def validate_timestamp(cls, value: date | datetime | str) -> date:
    if isinstance(value, date) and not isinstance(value, datetime):
        return value
    if isinstance(value, datetime):
        return value.date()
    try:
        return date.fromisoformat(value)
    except ValueError as e:
        raise ValueError("Invalid date format: expected YYYY-MM-DD") from e

applications/models/src/models/train_tft_model.py (3)

32-43: Use total_seconds() for accurate read timing.

.seconds drops minutes/hours and ignores subseconds. Prefer total_seconds().

Apply this diff:

-    runtime_seconds = (datetime.now(tz=timezone) - start_time).seconds
+    runtime_seconds = int((datetime.now(tz=timezone) - start_time).total_seconds())

---

111-126: Use total_seconds() for accurate validation timing.

Apply this diff:

-    runtime_seconds = (datetime.now(tz=timezone) - start_time).seconds
+    runtime_seconds = int((datetime.now(tz=timezone) - start_time).total_seconds())

---

130-139: Use total_seconds() for accurate save timing.

Apply this diff:

-    runtime_seconds = (datetime.now(tz=timezone) - start_time).seconds
+    runtime_seconds = int((datetime.now(tz=timezone) - start_time).total_seconds())

libraries/python/src/internal/dataset.py (2)

10-26: Add type hints for Scaler attributes

The Scaler class uses self.means and self.standard_deviations without type declarations, which could lead to typing issues and makes the code less self-documenting.

 class Scaler:
     def __init__(self) -> None:
-        pass
+        self.means: pl.DataFrame | None = None
+        self.standard_deviations: pl.DataFrame | None = None

     def fit(self, data: pl.DataFrame) -> None:

---

108-126: Consider extracting the magic number for Friday

The Friday number (4) is hardcoded and lacks context. Consider using a named constant for clarity.

-        friday_number = 4
+        FRIDAY_WEEKDAY_INDEX = 4  # Monday=0, ..., Friday=4
 
         # set is_holiday value for missing weekdays
         data = (
             data.with_columns(
                 pl.col("datetime").dt.weekday().alias("temporary_weekday")
             )
             .with_columns(
                 pl.when(
                     pl.col("is_holiday").is_null()
-                    & (pl.col("temporary_weekday") <= friday_number)
+                    & (pl.col("temporary_weekday") <= FRIDAY_WEEKDAY_INDEX)
                 )
                 .then(True)  # noqa: FBT003
                 .when(
                     pl.col("is_holiday").is_null()
-                    & (pl.col("temporary_weekday") > friday_number)
+                    & (pl.col("temporary_weekday") > FRIDAY_WEEKDAY_INDEX)
                 )

applications/positionmanager/src/positionmanager/main.py (1)

168-173: Consider extracting the type check to avoid duplication

The event data validation logic appears multiple times. Consider creating a helper function to validate event data format.

Create a helper function at the module level:

def validate_event_data(event_data: Any) -> dict:
    """Validate that event data is a dictionary."""
    if not isinstance(event_data, dict):
        raise ValueError("Invalid event data format, expected a dictionary.")
    return event_data

Then use it in the handler:

     try:
-        event_data = event.data
-        if not isinstance(event_data, dict):
-            return create_cloud_event_error(
-                application_name="positionmanager",
-                event_metadata=["positions", "open"],
-                error_message="Invalid event data format, expected a dictionary.",
-            )
+        event_data = validate_event_data(event.data)